/*
本题采用树的重心分治算法，结合动态规划的思想来求解。通过不断找到树的重心，将树分解，在每个子树中计算满足权值和为(K)的最少边数路径，并记录全局最优解。
*/
#define quickread
#ifdef quickread
#include <cstdio> 
template <typename T>
inline void read(T& x)
{
    int c=getchar(), f=1; x=0;
    while(c<'0'||'9'<c) {if(c=='-') f=-1; c=getchar();}
    while('0'<=c&&c<='9') 
        x=(x<<3)+(x<<1)+c-'0', c=getchar();
    x*=f;
}
template <typename T>
inline void quickwrite(T x)
{
    if(x<0) putchar('-'), x*=-1;
    if(x>=10) quickwrite(x/10);
    putchar(x%10+'0');
}
#else 
#include <iostream>
#endif
#include <cstring>
#include <algorithm>
using namespace std;
#define DEBUG
using PII=pair<int, int>;

#define x first
#define y second

const int N=200010, M=N<<1, S=1000010, INF=0x3f3f3f3f;

int n, m;
int h[N], e[M], w[M], ne[M], idx;
int f[S], ans=INF; //动态规划数组，存储权值和为某个值时的最少边数
PII p[N], q[N]; //所有子树的距离 q[]某些子树的距离 {权值，权值的最少边数}
bool st[N];

void AddEdge(int a, int b, int c)
{
    e[idx]=b, w[idx]=c, ne[idx]=h[a], h[a]=idx++; //
}

int GetSize(int u, int fa) //求子树大小
{
    if(st[u]) return 0;
    int res=1; //u的大小
    for(int i=h[u]; ~i; i=ne[i])
        if(e[i]!=fa)
            res+=GetSize(e[i], u);
    return res;
}

int GetWC(int u, int fa, int tot, int& wc) //求u为根节点的子树的重心wc
{
    if(st[u]) return 0;
    int sum=1, ms=0;//累加子树大小 最大子树大小
    for(int i=h[u]; ~i; i=ne[i])
    {
        int v=e[i];
        if(v==fa) continue;
        int t=GetWC(v, u, tot, wc); //子树重心，t为子树大小
        ms=max(ms, t); //更新最大子树
        sum+=t; //总节点个数
    }
    ms=max(ms, tot-sum); //u此时为根节点，任意一方向均为其子树，降低时间复杂度
    if(ms<=(tot>>1)) wc=u; //u为根节点的子树大小超过总结点的一半，则为重心
    return sum;
}

void GetDist(int u, int fa, int dist, int cnt, int& qt)
{
    if(st[u] || dist>m) return; //当前路径长度超过，剪枝
    q[qt++]={dist, cnt}; //将当前距离存入q[]中
    for(int i=h[u]; ~i; i=ne[i])
        if(e[i]!=fa)
            GetDist(e[i], u, dist+w[i], cnt+1, qt);
}

void calc(int u) //分治计算函数 处理u所在的树
{
    if(st[u]) return; //u已被删除
    int res=0;
    GetWC(u, -1, GetSize(u, -1), u); //得到u为根节点的子树的重心，并变为根节点
    st[u]=true; //u当作重心已被处理

    // 归并
    int pt=0; //p[]大小
    for(int i=h[u]; ~i; i=ne[i])
    {
        int v=e[i], qt=0; //q[]大小
        GetDist(v, u, w[i], 1, qt); //u->v大小为w[i]
        for(int k=0; k<qt; k++) //存到总距离中
        {
            auto &t=q[k];
            if(t.x==m) ans=min(ans, t.y); //路径长度相同，取最少边数
            ans=min(ans, f[m-t.x]+t.y); //取路权最小
            p[pt++]=t;
        }
        for(int k=0; k<qt; k++) //更新动态规划
        {
            auto &t=q[k];
            f[t.x]=min(f[t.x], t.y);
        }
    }
    for(int i=0; i<pt; i++) f[p[i].x]=INF;
    for(int i=h[u]; ~i; i=ne[i]) calc(e[i]);
}

void init()
{
    read(n), read(m);
    memset(h, -1, sizeof h);
    memset(f, 0x3f, sizeof f);
    for(int i=0; i<n-1; i++)
    {
        int a, b, c; read(a), read(b), read(c);
        AddEdge(a, b, c); AddEdge(b, a, c);
    }
}

void solve()
{
    init();
    calc(0);
    if(ans==INF) ans=-1;
    quickwrite(ans); puts("");
}

// #undef DEBUG
signed main()
{
    #ifdef DEBUG
        freopen("./in.txt", "r", stdin);
        freopen("./out.txt", "w", stdout);
    #endif
    #ifndef quickread
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    #endif

    int T=1; //scanf("%d", &T);
    while(T--) 
    {
        solve();
    }
    return 0;
}
